import {
  addGoodsToCart,
  deleteGoodsOfCartBySkuIds,
  getCartList,
  mergeCart,
  selectOrUnselectCartGoods,
  updateGoodsOfCart,
  updateGoodsOfCartBySkuId,
} from "@/api/cart";

const cart = {
  namespaced: true,
  state() {
    return {
      list: [],
    };
  },
  mutations: {
    // 添加商品到购物车
    addGoodsToCart(state, goods) {
      // 查找购物车中是否已有商品
      const index = state.list.findIndex((item) => item.skuId === goods.skuId);
      // 如果已经存在则数量加一,并删除
      if (index > -1) {
        state.list[index].count += goods.count;
        state.list.unshift(state.list.splice(index, 1)[0]);
      } else {
        // 在购物车列表开头添加商品;
        state.list.unshift(goods);
      }
    },
    // 删除商品
    deleteCart(state, skuId) {
      const index = state.list.findIndex((item) => item.skuId === skuId);
      state.list.splice(index, 1);
    },
    // 更新商品(自动)
    updateGoodsBySkuId(state, partOfGoods) {
      // 根据 skuId 查找商品
      let index = state.list.findIndex(
        (item) => item.skuId === partOfGoods.skuId
      );
      // 更新商品信息
      state.list[index] = { ...state.list[index], ...partOfGoods };
    },
    // 更新购物车
    setCart(state, payload) {
      state.list = payload;
    },
  },
  actions: {
    // 添加商品
    async addGoodsToCart({ rootState, commit, dispatch }, goods) {
      // 已登录
      if (rootState.user.profile.token) {
        await addGoodsToCart({ skuId: goods.skuId, count: goods.count });
        // 更新商品
        dispatch("updateCartList");
      } else {
        // 未登录
        commit("addGoodsToCart", goods);
      }
    },
    // 刪除商品
    async deleteCart({ rootState, commit, dispatch }, skuId) {
      // 判断是否登录
      if (rootState.user.profile.token) {
        // 登录
        await deleteGoodsOfCartBySkuIds([skuId]);
        // 更新购物车数据
        await dispatch("updateCartList");
      } else {
        // 未登录
        commit("deleteCart", skuId);
      }
    },
    // 更新本地购物车商品信息 (自定更新)
    async updateCartList({ rootState, state, commit }) {
      if (rootState.user.profile.token) {
        const data = await getCartList();
        commit("setCart", data.result);
      } else {
        // 未登录
        const promiseArray = state.list.map((item) => {
          return updateGoodsOfCartBySkuId(item.skuId);
        });
        Promise.all(promiseArray).then((dataCollection) => {
          dataCollection.forEach((data, index) => {
            // 为数据添加 skuId
            data.result.skuId = state.list[index].skuId;
            // 更新本地的商品数据
            commit("updateGoodsBySkuId", data.result);
          });
        });
      }
    },
    // 更改商品信息,(手动更改)
    async updateGoodsOfCartBySkuId({ rootState, commit, dispatch }, goods) {
      if (rootState.user.profile.token) {
        await updateGoodsOfCart(goods);
        // 更新
        dispatch("updateCartList");
        // 登录
      } else {
        // 未登录
        commit("updateGoodsBySkuId", goods);
      }
    },
    // 全选反选/
    async selectIsAll({ rootState, getters, commit, dispatch }, isAll) {
      if (rootState.user.profile.token) {
        // 登录
        const skuIds = getters.effectiveGoodsList.map((item) => item.skuId);
        await selectOrUnselectCartGoods({ selected: isAll, ids: skuIds });
        // 更新
        dispatch("updateCartList");
      } else {
        // 未登录
        getters.effectiveGoodsList.forEach((item) => {
          commit("updateGoodsBySkuId", { skuId: item.skuId, selected: isAll });
        });
      }
    },
    // 删除用户选择的商品、清空无效商品
    async delSelectedOrInvalid({ rootState, getters, commit, dispatch }, flag) {
      if (rootState.user.profile.token) {
        // 登录
        const skuIds = getters[flag].map((item) => item.skuId);
        await deleteGoodsOfCartBySkuIds(skuIds);
        // 更新购物车数据
        await dispatch("updateCartList");
      } else {
        // 未登录
        //flag  储存删除选择商品 或 清空无效商品
        getters[flag].forEach((item) => {
          commit("deleteCart", item.skuId);
        });
      }
    },
    // 商品规格信息发生变化, 更新商品信息
    async updateGoodsOfCartBySkuChanged(
      { rootState, state, commit, dispatch },
      { oldSkuId, userSelectedNewSku }
    ) {
      if (rootState.user.profile.token) {
        // 登录
        // 查找原有商品信息, 通过原有商品信息获取用户选择的商品数据
        const oldGoods = state.list.find((item) => item.skuId === oldSkuId);
        // 删除原有商品
        await deleteGoodsOfCartBySkuIds([oldSkuId]);
        // 添加新商品
        await addGoodsToCart({
          skuId: userSelectedNewSku.skuId,
          count: oldGoods.count,
        });
        // 更新购物车商品列表
        await dispatch("updateCartList");
      } else {
        // 未登录
        // 先根据旧的 skuId 查找商品, 根据旧商品生成新商品, 删除旧商品, 插入新商品
        // 查找旧商品
        const oldGoods = state.list.find((item) => item.skuId === oldSkuId);
        // 生成新商品
        const newGoods = {
          ...oldGoods,
          skuId: userSelectedNewSku.skuId,
          stock: userSelectedNewSku.inventory,
          oldPrice: userSelectedNewSku.oldPrice,
          nowPrice: userSelectedNewSku.price,
          attrsText: userSelectedNewSku.attrsText,
        };
        // 删除旧商品
        commit("deleteCart", oldSkuId);
        // 插入新商品
        commit("addGoodsToCart", newGoods);
      }
    },
    // 合并购物车
    async mergeCart({ state, commit }) {
      // 本地购物车没有数据时，不用合并
      if (state.list.length === 0) return;
      //准备合并购物车需要的数据
      const carts = state.list.map((item) => {
        return {
          skuId: item.skuId,
          selected: item.selected,
          count: item.count,
        };
      });
      try {
        // 合并购物车
        await mergeCart(carts);
        //删除本地购物车
        commit("setCart", []);
      } catch (error) {
        throw new Error(error);
      }
    },
  },
  getters: {
    // 可购买商品   有效商品 + 库存大于一
    effectiveGoodsList(state) {
      return state.list.filter((item) => item.isEffective && item.stock);
    },
    // 可购买商品总价
    effectiveGoodsPrice(state, getters) {
      return getters.effectiveGoodsList.reduce(
        (price, item) => price + Number(item.nowPrice) * item.count,
        0
      );
    },
    // 可购买商品数量
    effectiveGoodsCount(state, getters) {
      return getters.effectiveGoodsList.reduce(
        (count, item) => count + item.count,
        0
      );
    },
    // 不可购买的商品列表
    invalidGoodsList(state) {
      // 无效商品 , 库存小于一
      return state.list.filter(
        (item) => item.isEffective === false || item.stock < 1
      );
    },
    // 用户选择胡商品列表,
    userSelectedGoodsList(state, getters) {
      return getters.effectiveGoodsList.filter((item) => item.selected);
    },
    // 用户选择的商品的数量
    userSelectedGoodsCount(state, getters) {
      return getters.userSelectedGoodsList.reduce(
        (count, item) => count + item.count,
        0
      );
    },
    // 用户选择的商品总价
    userSelectedGoodsPrice(state, getters) {
      return getters.userSelectedGoodsList.reduce(
        (price, item) => price + item.count * Number(item.nowPrice),
        0
      );
    },
    // 全选按钮状态 (当选中商品与有效商品数量一致时全选, 有效商品为0是不选)
    selectAllButtonStatus(state, getters) {
      return (
        getters.effectiveGoodsList.length > 0 &&
        getters.effectiveGoodsList.length ===
          getters.userSelectedGoodsList.length
      );
    },
  },
};
export default cart;
